package com.demo.practiceui.views.animation;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;

import androidx.annotation.Nullable;

import java.util.Random;

/**
 * 高性能粒子效果View
 * 优化要点：
 * 1. 使用数组代替List，避免频繁的add/remove操作
 * 2. 使用对象池复用粒子对象
 * 3. 开启硬件加速
 * 4. 减少粒子数量，提高帧率
 * 5. 使用postInvalidateOnAnimation优化刷新
 */
public class ParticleView extends View {

    // 粒子池大小（减少到合理数量）
    private static final int MAX_PARTICLES = 80;
    
    // 共享Random对象，避免频繁创建
    private static final Random RANDOM = new Random();
    
    // 粒子颜色池
    private static final int[] COLORS = {
            0xFFFF5722,  // 红
            0xFFFFC107,  // 黄
            0xFF4CAF50,  // 绿
            0xFF2196F3,  // 蓝
            0xFF9C27B0   // 紫
    };

    /**
     * 粒子类 - 使用基本类型减少对象开销
     */
    private static class Particle {
        float x, y;           // 位置
        float vx, vy;         // 速度
        float radius;         // 半径
        int color;           // 颜色
        float life;          // 生命值（0-1）
        float decay;         // 衰减速度
        boolean alive;       // 是否存活

        void reset(float startX, float startY) {
            x = startX;
            y = startY;
            
            // 随机速度（向四周扩散）
            float angle = RANDOM.nextFloat() * 360;
            float speed = RANDOM.nextFloat() * 8 + 4;  // 增加初速度
            vx = (float) (Math.cos(Math.toRadians(angle)) * speed);
            vy = (float) (Math.sin(Math.toRadians(angle)) * speed) - 5;  // 向上偏移
            
            // 随机大小
            radius = RANDOM.nextFloat() * 6 + 3;
            
            // 随机颜色
            color = COLORS[RANDOM.nextInt(COLORS.length)];
            
            life = 1.0f;
            decay = RANDOM.nextFloat() * 0.015f + 0.01f;
            alive = true;
        }

        void update() {
            if (!alive) return;
            
            x += vx;
            y += vy;
            
            // 重力和空气阻力
            vy += 0.3f;
            vx *= 0.98f;
            vy *= 0.98f;
            
            // 生命值衰减
            life -= decay;
            if (life <= 0) {
                alive = false;
            }
        }
    }

    // 粒子池（数组，避免List的开销）
    private final Particle[] particles = new Particle[MAX_PARTICLES];
    private int activeParticles = 0;  // 活跃粒子数
    
    private Paint paint;
    
    // 尺寸
    private int width;
    private int height;
    
    // 动画控制
    private boolean isAnimating = false;
    
    // 性能优化：减少invalidate调用
    private long lastFrameTime = 0;
    private static final long FRAME_INTERVAL = 16;  // 约60fps

    public ParticleView(Context context) {
        this(context, null);
    }

    public ParticleView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public ParticleView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setStyle(Paint.Style.FILL);
        
        // 初始化粒子池
        for (int i = 0; i < MAX_PARTICLES; i++) {
            particles[i] = new Particle();
        }
        
        // 开启硬件加速
        setLayerType(LAYER_TYPE_HARDWARE, null);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        width = w;
        height = h;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        
        // 使用硬件加速绘制
        if (activeParticles == 0) {
            isAnimating = false;
            return;
        }
        
        // 绘制所有活跃粒子
        for (int i = 0; i < activeParticles; i++) {
            Particle p = particles[i];
            if (p.alive) {
                paint.setColor(p.color);
                paint.setAlpha((int) (255 * p.life));
                canvas.drawCircle(p.x, p.y, p.radius, paint);
            }
        }
        
        // 更新粒子状态
        updateParticles();
        
        // 继续动画
        if (isAnimating) {
            postInvalidateOnAnimation();
        }
    }

    /**
     * 更新粒子状态
     */
    private void updateParticles() {
        int aliveCount = 0;
        
        for (int i = 0; i < activeParticles; i++) {
            Particle p = particles[i];
            if (p.alive) {
                p.update();
                
                // 边界检查，超出屏幕的粒子标记为死亡
                if (p.x < -50 || p.x > width + 50 || p.y > height + 50) {
                    p.alive = false;
                }
                
                if (p.alive) {
                    aliveCount++;
                }
            }
        }
        
        activeParticles = aliveCount;
    }

    /**
     * 爆炸效果
     */
    public void explode(float x, float y) {
        // 清除旧粒子
        activeParticles = 0;
        
        // 创建新粒子（减少到40个）
        int particleCount = Math.min(40, MAX_PARTICLES);
        for (int i = 0; i < particleCount; i++) {
            particles[i].reset(x, y);
        }
        activeParticles = particleCount;
        
        // 开始动画
        if (!isAnimating) {
            isAnimating = true;
            postInvalidateOnAnimation();
        }
    }

    /**
     * 停止发射（清空粒子）
     */
    public void stopEmit() {
        for (int i = 0; i < activeParticles; i++) {
            particles[i].alive = false;
        }
        activeParticles = 0;
        isAnimating = false;
        invalidate();
    }

    /**
     * 清除所有粒子
     */
    public void clear() {
        stopEmit();
    }
    
    /**
     * 暂停动画
     */
    public void pause() {
        isAnimating = false;
    }
    
    /**
     * 恢复动画
     */
    public void resume() {
        if (activeParticles > 0) {
            isAnimating = true;
            postInvalidateOnAnimation();
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        isAnimating = false;
    }
    
    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        // 视图附加时不自动开始动画
    }
}
